# -*- coding: utf-8 -*-
# @Time    : 2024/6/5 16:01
# @Author  : yujiahao
# @File    : 02_if_match.py
# @description:Python中的流程控制：if-else 、match


# todo 1、了解一下Python代码的缩进
"""
这里开始进行书写逻辑代码，和Java、Scala不同的是，Python没有明显的{}作为作用域，而是用缩进，
也因此Python代码看起来比较舒服，不像其他的用；结尾或者花括号结尾代码可以随意变动行数和缩进，这一点虽然刚开始不好把握，但是抵不住代码漂亮啊。

1. 缩进的作用

    在 Python 中，缩进用于表示代码块的层次结构。不同于 Java 和 Scala 使用花括号 `{}` 来包围代码块，Python 使用缩进来明确代码块的开始和结束。这种设计使得代码更加简洁和易读，但也要求开发者严格遵守缩进规则。

2. 缩进规则

    - 每个代码块必须有相同数量的缩进。
    - 缩进可以使用空格或制表符，但推荐使用空格。
    - PEP 8（Python 的官方编码规范）推荐使用 4 个空格来表示一个缩进层级。
    - 同一个代码块中的所有行必须使用相同类型和数量的缩进。

3. 缩进示例

    正确的缩进示例：
    ```python
    x = 10
    if x > 0:
        print("x is positive")
        if x > 5:
            print("x is greater than 5")
    else:
        print("x is non-positive")
    ```

    错误的缩进示例：
    ```python
    x = 10
    if x > 0:
      print("x is positive")  # 错误：缩进不一致（2 个空格）
        if x > 5:
            print("x is greater than 5")  # 错误：缩进不一致（4 个空格）
    else:
        print("x is non-positive")
    ```

4. 缩进的常见问题和解决方法

    - 【混用空格和制表符】：混用空格和制表符会导致 `IndentationError`。解决方法是统一使用空格或制表符，推荐使用 4 个空格。
    - 【不一致的缩进】：同一个代码块内的缩进必须一致，否则会导致 `IndentationError`。解决方法是确保同一代码块内的所有行使用相同数量的缩进。
    - 【编辑器配置】：配置代码编辑器以自动使用 4 个空格替代制表符。这可以避免手动缩进时的错误。

5. PEP 8 缩进推荐

    - 使用 4 个空格来表示一个缩进层级。
    - 确保同一个文件中的缩进方式一致。
    - 可以通过配置编辑器（如 VSCode、PyCharm）来自动格式化代码，使其符合 PEP 8 标准。

6. 示例代码

    下面是一个符合 PEP 8 缩进规则的示例代码：
    ```python
    def check_number(x):
        if x > 0:
            print("x is positive")
            if x > 5:
                print("x is greater than 5")
        elif x < 0:
            print("x is negative")
        else:
            print("x is zero")

    check_number(10)
    ```

    这个示例中，所有的缩进都使用了 4 个空格，符合 PEP 8 规范，并且确保了代码的可读性和一致性。
"""

# todo 2、控制语句

"""
Java, Scala 和 Python 的条件控制语句语法结构对比

1. Java

    ① if 语句
        语法结构：
            if (condition) {
                // code block
            } else if (another_condition) {
                // another code block
            } else {
                // default code block
            }
        
        说明：
            - `if` 后面的条件必须放在圆括号内。
            - 每个代码块必须用花括号 `{}` 包围，即使代码块只有一行。
            - `else if` 和 `else` 是可选的，可以有多个 `else if` 语句，但最多只能有一个 `else` 语句。
            - 条件表达式必须返回一个布尔值 (boolean)。
        
        示例：
            int x = 10;
            if (x > 0) {
                System.out.println("x is positive");
            } else if (x < 0) {
                System.out.println("x is negative");
            } else {
                System.out.println("x is zero");
            }

    ② switch 语句
        语法结构：
            switch (expression) {
                case value1:
                    // code block
                    break;
                case value2:
                    // another code block
                    break;
                // more cases...
                default:
                    // default code block
            }
        
        说明：
            - `switch` 后面的表达式可以是整数、枚举、字符串或字符。
            - 每个 `case` 语句后面必须跟一个 `break` 语句以防止“贯穿”。
            - `default` 语句是可选的，用于处理所有未匹配的情况。
        
        示例：
            int day = 3;
            switch (day) {
                case 1:
                    System.out.println("Monday");
                    break;
                case 2:
                    System.out.println("Tuesday");
                    break;
                case 3:
                    System.out.println("Wednesday");
                    break;
                // more cases...
                default:
                    System.out.println("Invalid day");
            }

2. Scala

    ① if 语句
        语法结构：
            if (condition) {
                // code block
            } else if (another_condition) {
                // another code block
            } else {
                // default code block
            }
        
        说明：
            - `if` 后面的条件可以不放在圆括号内，但推荐使用圆括号以提高可读性。
            - 代码块可以用花括号 `{}` 包围，单行代码块可以省略花括号。
            - `else if` 和 `else` 是可选的，可以有多个 `else if` 语句，但最多只能有一个 `else` 语句。
            - 条件表达式必须返回一个布尔值 (Boolean)。
            - `if` 语句是有返回值的，可以用于赋值操作。
        
        示例：
            val x = 10
            if (x > 0) {
                println("x is positive")
            } else if (x < 0) {
                println("x is negative")
            } else {
                println("x is zero")
        
        注意事项：
            -Scala是完全面向对象编程，函数式编程可以将 `if` 语句的结果赋值给变量。例如：
              val result = if (x > 0) "positive" else "non-positive"

    ② match 语句
        语法结构：
            expression match {
                case pattern1 => // code block
                case pattern2 => // another code block
                // more cases...
                case _ => // default code block
            }
        
        说明：
            - `match` 语句类似于 Java 的 `switch` 语句，但功能更强大。
            - 每个 `case` 可以匹配一个模式，`_` 表示默认情况。
            - `match` 语句是有返回值的，可以用于赋值操作。
        
        示例：
            val day = 3
            day match {
                case 1 => println("Monday")
                case 2 => println("Tuesday")
                case 3 => println("Wednesday")
                // more cases...
                case _ => println("Invalid day")
            }

3. Python

    ① if 语句
        语法结构：
            if condition:
                # code block
            elif another_condition:
                # another code block
            else:
                # default code block
        
        说明：
            - `if` 后面的条件不需要放在圆括号内。
            - 代码块通过缩进来表示，不需要花括号 `{}`。
            - `elif` 是 `else if` 的缩写形式，用于简化代码。
            - `else` 是可选的，可以有多个 `elif` 语句，但最多只能有一个 `else` 语句。
            - 条件表达式必须返回一个布尔值 (boolean)。
        
        示例：
            x = 10
            if x > 0:
                print("x is positive")
            elif x < 0:
                print("x is negative")
            else:
                print("x is zero")
        
        注意事项：
            - 缩进用于表示代码块，推荐使用4个空格的缩进。
            - `elif` 是 `else if` 的缩写形式，用于简化代码。

    ② match 语句（Python 3.10+）
        语法结构：
            match subject:
                case pattern1:
                    # code block
                case pattern2:
                    # another code block
                # more cases...
                case _:
                    # default code block
        
        说明：
            - `match` 语句类似于 Scala 的 `match` 语句，用于模式匹配。
            - 每个 `case` 可以匹配一个模式，`_` 表示默认情况。
            - `match` 语句是有返回值的，可以用于赋值操作。
        
        示例：
            day = 3
            match day:
                case 1:
                    print("Monday")
                case 2:
                    print("Tuesday")
                case 3:
                    print("Wednesday")
                # more cases...
                case _:
                    print("Invalid day")
"""




# todo 3、从控制台输入数据


'''

 为啥要说这个，咱们后面流程控制小游戏要用一下
 
1. 从控制台输入数据的基本方法

    在 Python、Java 和 Scala 中，从控制台读取用户输入的方法如下：
    
    Python:
        使用内置的 `input` 函数从控制台读取用户输入。该函数会将用户输入的数据作为字符串返回。
    
        示例代码：
        # 读取一个字符串输入
        user_input = input("请输入一段话，回车提交: ")
        print(f"您输入的内容是: {user_input}")
        
    Java:
        使用 `Scanner` 类从控制台读取用户输入。
        
        示例代码：
        import java.util.Scanner;
        
        public class Main {
            public static void main(String[] args) {
                Scanner scanner = new Scanner(System.in);
                System.out.print("请输入一段话，回车提交: ");
                String userInput = scanner.nextLine();
                System.out.println("您输入的内容是: " + userInput);
            }
        }
    
    Scala:
        使用 `scala.io.StdIn` 对象从控制台读取用户输入。
        
        示例代码：
        object Main extends App {
            print("请输入一段话，回车提交: ")
            val userInput = scala.io.StdIn.readLine()
            println(s"您输入的内容是: $userInput")
        }

2. 将输入转换为其他数据类型

    Python:
        由于 `input` 函数返回的始终是字符串，如果需要其他数据类型（如整数或浮点数），需要进行类型转换。
        
        示例代码：
        # 读取一个整数输入
        number = int(input("Enter a number: "))
        print(f"You entered the number: {number}")
        
        # 读取一个浮点数输入
        floating_number = float(input("Enter a floating point number: "))
        print(f"You entered the floating point number: {floating_number}")

    Java:
        使用 `Scanner` 类的相应方法进行类型转换。
        
        示例代码：
        import java.util.Scanner;
        
        public class Main {
            public static void main(String[] args) {
                Scanner scanner = new Scanner(System.in);
                System.out.print("Enter a number: ");
                int number = scanner.nextInt();
                System.out.println("You entered the number: " + number);
        
                System.out.print("Enter a floating point number: ");
                float floatingNumber = scanner.nextFloat();
                System.out.println("You entered the floating point number: " + floatingNumber);
            }
        }

    Scala:
        使用 `scala.io.StdIn` 对象的相应方法进行类型转换。
        
        示例代码：
        object Main extends App {
            print("Enter a number: ")
            val number = scala.io.StdIn.readInt()
            println(s"You entered the number: $number")
        
            print("Enter a floating point number: ")
            val floatingNumber = scala.io.StdIn.readDouble()
            println(s"You entered the floating point number: $floatingNumber")
        }

3. 处理多个输入

    Python:
        可以使用 `input` 函数多次读取多个输入，或使用 `split` 方法一次性读取多个输入并进行处理。
    
        示例代码：
        # 分别读取两个输入
        first_input = input("Enter first value: ")
        second_input = input("Enter second value: ")
        print(f"You entered: {first_input} and {second_input}")
        
        # 一次性读取多个输入，并将其拆分成列表
        multiple_inputs = input("Enter multiple values separated by space: ").split()
        print(f"You entered: {multiple_inputs}")

    Java:
        可以使用 `Scanner` 类的 `nextLine` 方法读取一行输入，并使用 `split` 方法拆分成多个值。
        
        示例代码：
        import java.util.Scanner;
        
        public class Main {
            public static void main(String[] args) {
                Scanner scanner = new Scanner(System.in);
                System.out.print("Enter multiple values separated by space: ");
                String[] inputs = scanner.nextLine().split(" ");
                System.out.println("You entered: ");
                for (String input : inputs) {
                    System.out.println(input);
                }
            }
        }

    Scala:
        可以使用 `scala.io.StdIn.readLine` 方法读取一行输入，并使用 `split` 方法拆分成多个值。
        
        示例代码：
        object Main extends App {
            print("Enter multiple values separated by space: ")
            val inputs = scala.io.StdIn.readLine().split(" ")
            println("You entered: ")
            inputs.foreach(println)
        }

4. 注意事项

    Python:
    - 确保进行类型转换时输入的内容是有效的。例如，将字符串转换为整数时，输入必须是数字，否则会引发 `ValueError` 异常。
    - 可以使用异常处理机制来处理可能的输入错误。

        示例代码：
        # 带有异常处理的输入读取
        try:
            number = int(input("Enter a number: "))
            print(f"You entered the number: {number}")
        except ValueError:
            print("Invalid input! Please enter a valid number.")
        
    Java:
    - 使用 `Scanner` 类时，要注意关闭 `Scanner` 对象以释放资源。
    - 确保输入的数据类型正确，否则会引发 `InputMismatchException` 异常。
    
        示例代码：
        import java.util.Scanner;
        
        public class Main {
            public static void main(String[] args) {
                Scanner scanner = new Scanner(System.in);
                try {
                    System.out.print("Enter a number: ");
                    int number = scanner.nextInt();
                    System.out.println("You entered the number: " + number);
                } catch (InputMismatchException e) {
                    System.out.println("Invalid input! Please enter a valid number.");
                } finally {
                    scanner.close();
                }
            }
        }

    Scala:
    - 使用 `scala.io.StdIn` 时，要确保输入的数据类型正确，否则会引发相应的异常。
    - 可以使用异常处理机制来处理可能的输入错误。

        示例代码：
        object Main extends App {
            try {
                print("Enter a number: ")
                val number = scala.io.StdIn.readInt()
                println(s"You entered the number: $number")
            } catch {
                case e: NumberFormatException => println("Invalid input! Please enter a valid number.")
            }
        }
'''


# todo 4、综合练习一下


"""用Python设计第一个游戏
需求：如果输入的是数字8 则匹配上，否则匹配不上
练习的要点：
1、从控制台输入
2、类型转换
3、if语句
4、缩进（最外层的print怎么都会执行）

注意：这里先输入数字，不要输入其他，否则报错，后续慢慢加 """
# 1、从控制台接受的是字符串类型的数字，
temp = input("不妨猜一下豪哥现在心里想的是那个数字: ")
# 2、将数字转换成int
guess = int(temp)

# 3、使用if
if guess == 8:
    print("你是豪哥心里的蛔虫吗？！")
    print("哼，猜中了也没有奖励 ")
elif guess == 20:
    print("我是20")
else:
    print("猜错啦，豪哥心里现在想的是8！")

print("游戏结束，不玩啦(#^.^#)")


# 4、使用match

match guess:
    case 8:
        print("你是豪哥心里的蛔虫吗？！")
        print("哼，猜中了也没有奖励 ")
    case 20:
        print("我是20")
    case _:
        print("猜错啦，豪哥心里现在想的是8！")

print("游戏结束，不玩啦(#^.^#)")
